/**
 * 3种离散的概率分布
 * 1. 二项分布
 * 2. 泊松分布
 * 3. 几何分布
 *
 *
 * 1种连续的概率分布
 * 正太分布.
 */


import MathUtils from '../math_utils';

let Dispersed = {

    /**
     * 二项分布 概率
     * example:
     *     投5次硬币,恰好3次  正面朝上的概率.
     *     Dispersed.erXiangFenbu(5,3,0.5)
     * @param n {number}  总的次数
     * @param x {number}  出现事件的次数
     * @param p {number}  事件发生的概率
     * @return {number}
     */
    erXiangFenbu(n,x,p){
        return MathUtils.cnk(n,x) * Math.pow(p,x) * Math.pow(1 - p ,n - x);
    },


    /**
     * 二项分布 的期望: 预计发生的次数. 如：
     *    抛硬币 100次, 正面朝上的期望次数为 100 * 0.5 = 50 次
     * @param n {number}  总次数
     * @param p {number}  发生的概率
     * @return {number}
     */
    erXiangExpect(n,p){
        return n * p;
    },

    /**
     * 标准差:标准差是方差的平方根
     * @param n
     * @param p
     * @return {number}
     */
    erXiangBiaozhuncha(n,p){
        return Math.sqrt(n * p * ( 1 - p));
    },



    //----------------------
    // 几何分布:进行x次尝试这个事情，取得第1次成功的概率是多大。
    /**
     * p为成功概率，即为了在第x次尝试取得第1次成功,所以先要失败（x-1）次。
     * @param x
     * @param p
     * @return {number}
     */
    jiheFenbu(x,p){
        return Math.pow(1 - p,x - 1) * p;
    },

    /**
     * 期望
     * @param p
     * @return {number}
     */
    jiheExpect(p){
        return 1.0 / p;
    },

    /**
     * 标准差
     * @param p
     * @return {number}
     */
    jiheBiaozhuncha(p){
        return ( 1 - p) / (p * p);
    },

    //----------------------------
    // 泊松分布
    /**
     * 用 x 代表事情发的次数（例如中奖10个人中奖）,
     *  u 代表给定时间范围内事情发生的平均次数.
     *  如: 1天内中奖的平均个数为5个，你想知道1天内恰巧中奖次数为7的概率是多少?
     *  此时x=7，u=5,带入即可.
     *
     *  泊松概率还有一个重要性质，它的数学期望和方差相等，都等于u.
     *   注意是方差和期望相等,不是标准差.
     * @param u
     * @param x
     * @return {number}
     */
    bosongFenbu(u,x){
        return Math.pow(u,x) * Math.pow( Math.E,-u) / MathUtils.ank(x,x);
    },


    //------------------------------
    // 正太分布
    /**
     * 当 均值u=0，标准差σ=1的正态分布叫做标准正态分布
     * @param x
     * @param u
     * @param bzc
     * @return {number}
     */
    zhengtaiFenbu(x,u,bzc){
        return  Math.pow(Math.E,-(x - u) * (x - u) / (2 * bzc * bzc))  / (bzc * Math.sqrt(2 * Math.PI));
    }
};

export  default Dispersed;
